home *** CD-ROM | disk | FTP | other *** search
/ Internet Surfer: Getting Started / Internet Surfer - Getting Started (Wayzata Technology)(7231)(1995).bin / pc / textfile / mac_faqs / obj_c / sample_p < prev   
Text File  |  1995-01-30  |  8KB  |  219 lines
  1. Xref: bloom-picayune.mit.edu comp.lang.objective-c:1011 news.answers:4554
  2. Path: bloom-picayune.mit.edu!enterpoop.mit.edu!spool.mu.edu!olivea!sun-barr!cs.utexas.edu!bcm!aio!fdr!shirley
  3. From: shirley@fdr.uucp (Bill Shirley [CSC])
  4. Newsgroups: comp.lang.objective-c,news.answers
  5. Subject: Objective-C Simple Sample Program - FAQ
  6. Summary: A simple Objective-C program to give a sample of the syntax
  7.     to someone unfamiliar with the language.
  8. Message-ID: <objc-prog_724237201@fdr.jsc.nasa.edu>
  9. Date: 13 Dec 92 09:00:40 GMT
  10. Expires: 26 Jan 1993 09:00:01 GMT
  11. References: <objc_724237201@fdr.jsc.nasa.edu>
  12. Sender: news@aio.jsc.nasa.gov (USENET News System)
  13. Followup-To: comp.lang.objective-c
  14. Organization: nasa-jsc
  15. Lines: 200
  16. Approved: news-answers-request@MIT.Edu
  17. Supersedes: <objc-prog_721077644@fdr.jsc.nasa.edu>
  18.  
  19. Archive-name: Objective-C/sample-program
  20. Last-modified: 1992/11/01
  21. Version: 1.0
  22.  
  23.         A S[ia]mple Objective-C Program
  24.     (a companion to the comp.lang.Objective-C FAQ file)
  25.  
  26. // This is a comment.  Everything to the right of a double slash
  27. // is ignored (until an end of line is reached).
  28.  
  29. /*
  30.  * This is too, that's what superset of ANSI C means; You can do
  31.  *  anything you can do in C in Objective-C.  (not to suggest that
  32.  *  you should, only that you could.)
  33.  */
  34.  
  35. // The first thing we do is bring in some include files, as in
  36. // C.  However, we'll use the "import" statement which guarantees
  37. // that the file isn't included more than once.
  38.  
  39. // <objc/Object.h> is not really needed, because it is #imported
  40. // by the Queue and Stack headers, but we (as object users) don't
  41. // necessarily know that, so it is good practice to #import it 
  42. // here.  (When the processer reaches #import <objc/Object.h>
  43. // in the Queue and Stack headers, it will not include it.)
  44.  
  45. #import <stdio.h>
  46. #import <objc/Object.h>
  47. #import "Queue.h"
  48. #import "Stack.h"
  49.  
  50. // GNU gcc for some reason passes moral judgement on the useage
  51. // of #import, but still allows it.  They suggest you use #ifndefs
  52. // in all of your header files to eliminate multiple includes.
  53.  
  54. // That brought in class definitions for Objects, Queues, and
  55. // Stacks.  Queue and Stack are classes of my own construction,
  56. // and I'm not going to go into details here.  You don't need
  57. // to know how they work.  The Object class is the basis for
  58. // all other classes, which is why it gets brought in first.
  59.  
  60. // Classes are the one real extension which Objective C adds to
  61. // C.  A class is a description of a collection of data, like a
  62. // C structure, and the methods by which that data may be accessed
  63. // or manipulated.  Instances of a class are called objects, and
  64. // methods are invoked by sending messages to either the class itself,
  65. // to produce objects, or to those objects.  The recipient of a message
  66. // is called a "receiver".  The form of a message is:
  67. //
  68. //    [receiver method andMaybeSomeArguments]
  69. //
  70. // the receiver and method components are mandatory, as are 
  71. // the square brackets surrounding the message.  Additional
  72. // arguments may or may not be present, depending upon the
  73. // method definition.  Messages may appear anywhere a statement
  74. // is allowed in C.
  75.  
  76. // Two simple Class definitions follow.  Both inherit
  77. // directly from the base class "Object".  This gives
  78. // them lots of nice properties, not the least of which
  79. // is the ability to be referenced by any pointer of the
  80. // generic object type "id".  All objects can be pointed
  81. // to by any id variable, and the default return type from
  82. // methods is id.  This allows messages to be embedded in
  83. // other messages, either as receivers or arguments.
  84.  
  85. // An Int object allocates space for a single integer.
  86. // The "report" message causes it to report its value.
  87. // Everything between the @implementation and the @end
  88. // is part of the class definition...
  89.  
  90. @implementation Int: Object    // Int is derived from Object
  91. {
  92.     int value;        // This is the data portion.  Like a struct.
  93. }
  94.  
  95. // The following are the method definitions.  The "+" means this
  96. // is a class method, i.e., a method that deals with classes instead
  97. // on instances.  In this case it is a factory method, or one which
  98. // creates and returns a new instance of a class  The body of the
  99. // method is between braces, like a C function.
  100.  
  101. // Self is a special variable which may only be used within a method
  102. // and means the receiver of the message which invoked this message.
  103. // Super means that when searching for the method for this message
  104. // start in the parent class of the present implementation.  This
  105. // does not, necessarily, have any relation to the value of self.
  106.  
  107. + makeRoomFor: (int) i
  108. {
  109.   id  anInstance;
  110.  
  111.   anInstance  = [super new];
  112.   value = i;
  113.   return anInstance;
  114. }
  115.  
  116. // It is standard for methods that do not need to return any
  117. // special value to instead return self.  This allows for a 
  118. // nested syntax of method calls.
  119.  
  120. // The "-" in front of report means that it's an instance method,
  121. // i.e., how a particular object should respond.
  122.  
  123. - report
  124. {
  125.   printf("%4d", value);
  126.   return self;
  127. }
  128.  
  129. @end
  130.  
  131.  
  132. // Same for a Float object, but for the obvious difference that
  133. // it works with floats.
  134. // Note polymorphism -- methods have same names as in the Int class.
  135.  
  136. @implementation Float: Object
  137. {
  138.   float value;
  139. }
  140.  
  141. // Sometimes a factory method is written in the following manner.  This
  142. // is not strictly correct, but since _self_ is a local variable, no 
  143. // harm is done.  It is also quite common to see this in code from the
  144. // net, so it is included here.  In this case _self_, which is a class,
  145. // is assigned to return a value from [super new], which is an instance.
  146. // It may even help the compiler optimize if there is no assignment to
  147. // self while in a class method.
  148.  
  149. + makeRoomFor: (float) x
  150. {
  151.   self = [super new];
  152.   value = x;
  153.   return self;
  154. }
  155.  
  156. - report
  157. {
  158.   printf("%4.1f", value);
  159.   return self;
  160. }
  161.  
  162. @end
  163.  
  164. void main()
  165. {
  166.     // First we create instances of "Stack" and "Queue" data structures
  167.  
  168.     id queue = [Queue new];
  169.     id stack = [Stack new];
  170.     int i;
  171.  
  172.     for (i = 5; i > -6; --i)
  173.     {
  174.     // We alternate putting Int's and Floats onto the queue and
  175.     // stack, based on whether "i" is odd or even.  Whatever
  176.     // type goes on the queue, the opposite goes on the stack.
  177.  
  178.     [queue put: (i & 1) ? [Int makeRoomFor: i] : [Float makeRoomFor: i]];
  179.     [stack put: (i & 1) ? [Float makeRoomFor: i] : [Int makeRoomFor: i]];
  180.     }
  181.     while ([queue size] && [stack size])
  182.     {
  183.     // The following illustrates run-time binding.  Will report be
  184.     // invoked for a Float object or an Int object?  We don't know
  185.     // ahead of time, but with run-time binding and polymorphism
  186.     // it works the way we like.  The burden is on the class
  187.     // implementor rather than the class user.  In fact, we
  188.     // could add another class (String?  Complex?) and toss
  189.     // instances onto the Stack and Queue without having to
  190.     // change the following lines at all.
  191.  
  192.     // Both classes, Int and Float, just happen to implement the
  193.     // method 'report'.  They do not need to inherit from some
  194.     // object 'Reportable', only to implement the report method.
  195.     // If one did not implement the method, the message would
  196.     // not be sent.
  197.  
  198.     printf("queue=");    [[[queue get] report] free];
  199.     printf(", stack=");    [[[stack get] report] free];
  200.     putchar('\n');
  201.     }
  202. }
  203.  
  204. ______
  205. If you have any questions, corrections, comment, suggestions pass them
  206. along.  I can be reached directly at <shirley@krakatoa.jsc.nasa.gov> or you
  207. can post to the news group (comp.lang.objective-c)
  208.  
  209. Thanks to Paul J. Sanchez, paul@music.sie.arizona.edu, for writing this
  210. program.
  211. -- 
  212.  Bill Shirley
  213.  shirley@fdr.jsc.nasa.gov
  214. -- 
  215.     ``One lonesome body,        Bill Shirley
  216.       one lonesome song.        shirley@fdr.jsc.nasa.gov
  217.       No lonesome body,
  218.       no lonesome song.'' - throwing muses
  219.